{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "life is OK\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM\n",
    "import  pandas as pd\n",
    "import  os\n",
    "from keras.models import Sequential, load_model\n",
    "print(\"life is OK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     year      month  passengers\n",
      "0    1949    January         112\n",
      "1    1949   February         118\n",
      "2    1949      March         132\n",
      "3    1949      April         129\n",
      "4    1949        May         121\n",
      "..    ...        ...         ...\n",
      "139  1960     August         606\n",
      "140  1960  September         508\n",
      "141  1960    October         461\n",
      "142  1960   November         390\n",
      "143  1960   December         432\n",
      "\n",
      "[144 rows x 3 columns]\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('flights.csv')\n",
    "\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('flights.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     passengers\n",
      "0           112\n",
      "1           118\n",
      "2           132\n",
      "3           129\n",
      "4           121\n",
      "..          ...\n",
      "136         472\n",
      "137         535\n",
      "138         622\n",
      "139         606\n",
      "140         508\n",
      "\n",
      "[141 rows x 1 columns]\n",
      "[[112]\n",
      " [118]\n",
      " [132]\n",
      " [129]\n",
      " [121]\n",
      " [135]\n",
      " [148]\n",
      " [148]\n",
      " [136]\n",
      " [119]\n",
      " [104]\n",
      " [118]\n",
      " [115]\n",
      " [126]\n",
      " [141]\n",
      " [135]\n",
      " [125]\n",
      " [149]\n",
      " [170]\n",
      " [170]\n",
      " [158]\n",
      " [133]\n",
      " [114]\n",
      " [140]\n",
      " [145]\n",
      " [150]\n",
      " [178]\n",
      " [163]\n",
      " [172]\n",
      " [178]\n",
      " [199]\n",
      " [199]\n",
      " [184]\n",
      " [162]\n",
      " [146]\n",
      " [166]\n",
      " [171]\n",
      " [180]\n",
      " [193]\n",
      " [181]\n",
      " [183]\n",
      " [218]\n",
      " [230]\n",
      " [242]\n",
      " [209]\n",
      " [191]\n",
      " [172]\n",
      " [194]\n",
      " [196]\n",
      " [196]\n",
      " [236]\n",
      " [235]\n",
      " [229]\n",
      " [243]\n",
      " [264]\n",
      " [272]\n",
      " [237]\n",
      " [211]\n",
      " [180]\n",
      " [201]\n",
      " [204]\n",
      " [188]\n",
      " [235]\n",
      " [227]\n",
      " [234]\n",
      " [264]\n",
      " [302]\n",
      " [293]\n",
      " [259]\n",
      " [229]\n",
      " [203]\n",
      " [229]\n",
      " [242]\n",
      " [233]\n",
      " [267]\n",
      " [269]\n",
      " [270]\n",
      " [315]\n",
      " [364]\n",
      " [347]\n",
      " [312]\n",
      " [274]\n",
      " [237]\n",
      " [278]\n",
      " [284]\n",
      " [277]\n",
      " [317]\n",
      " [313]\n",
      " [318]\n",
      " [374]\n",
      " [413]\n",
      " [405]\n",
      " [355]\n",
      " [306]\n",
      " [271]\n",
      " [306]\n",
      " [315]\n",
      " [301]\n",
      " [356]\n",
      " [348]\n",
      " [355]\n",
      " [422]\n",
      " [465]\n",
      " [467]\n",
      " [404]\n",
      " [347]\n",
      " [305]\n",
      " [336]\n",
      " [340]\n",
      " [318]\n",
      " [362]\n",
      " [348]\n",
      " [363]\n",
      " [435]\n",
      " [491]\n",
      " [505]\n",
      " [404]\n",
      " [359]\n",
      " [310]\n",
      " [337]\n",
      " [360]\n",
      " [342]\n",
      " [406]\n",
      " [396]\n",
      " [420]\n",
      " [472]\n",
      " [548]\n",
      " [559]\n",
      " [463]\n",
      " [407]\n",
      " [362]\n",
      " [405]\n",
      " [417]\n",
      " [391]\n",
      " [419]\n",
      " [461]\n",
      " [472]\n",
      " [535]\n",
      " [622]\n",
      " [606]\n",
      " [508]]\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('./flights.csv', usecols=[2], engine='python', skipfooter=3)#选择每个月的乘客人数列作为df\n",
    "dataset = df.values#只要value \n",
    "print(df)\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset = dataset.astype('float32')\n",
    "\n",
    "plt.plot(dataset)\n",
    "plt.show()\n",
    "#从这 12 年的数据可以看到上升的趋势，每一年内的 12 个月里又有周期性季节性的规律"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 需要把数据做一下转化:\n",
    "解释1：\n",
    "将一列变成两列，第一列是 t 月的乘客数，第二列是 t+1 列的乘客数。\n",
    "look_back 就是预测下一步所需要的 time steps：\n",
    "\n",
    "timesteps 就是 LSTM 认为每个输入数据与前多少个陆续输入的数据有联系。例如具有这样用段序列数据 “…ABCDBCEDF…”，当 timesteps 为 3 时，在模型预测中如果输入数据为“D”，那么之前接收的数据如果为“B”和“C”则此时的预测输出为 B 的概率更大，之前接收的数据如果为“C”和“E”，则此时的预测输出为 F 的概率更大。\n",
    "解释2：\n",
    "对数据进行处理\n",
    "LSTM进行预测需要的是时序数据 根据前timestep步预测后面的数据\n",
    "假定给一个数据集\n",
    "{\n",
    "A,B,C->D\n",
    "B,C,D->E\n",
    "C,D,E->F\n",
    "D,E,F->G\n",
    "E,F,G->H\n",
    "}\n",
    "这时timestep为3，即根据前三个的数据预测后一个数据的值\n",
    "所以我们需要对数据进行转化\n",
    "举一个简单的情况 假设一个list为[1,2,3,4,5],timestep = 2\n",
    "我们转化之后要达到的效果是\n",
    "![image.png](attachment:image.png)\n",
    "#即依据前两个值预测下一个值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X is the number of passengers at a given time (t) and Y is the number of passengers at the next time (t + 1).\n",
    "\n",
    "# convert an array of values into a dataset matrix\n",
    "def create_dataset(dataset, look_back=1):\n",
    "    dataX, dataY = [], []\n",
    "    for i in range(len(dataset)-look_back-1):\n",
    "        a = dataset[i:(i+look_back), 0]\n",
    "        dataX.append(a)\n",
    "        dataY.append(dataset[i + look_back, 0])\n",
    "    return numpy.array(dataX), numpy.array(dataY)\n",
    "\n",
    "# fix random seed for reproducibility\n",
    "numpy.random.seed(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 当激活函数为 sigmoid 或者 tanh 时，要把数据正则话，此时 LSTM 比较敏感，设定 67% 是训练数据，余下的是测试数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 对数据进行归一化\n",
    "LSTM可以不进行归一化的操作，但是这样会让训练模型的loss下降很慢。本教程如果不进行归一化，100次迭代后loss还是很高"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error\n",
    "# normalize the dataset\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "dataset = scaler.fit_transform(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split into train and test sets\n",
    "train_size = int(len(dataset) * 0.67)\n",
    "test_size = len(dataset) - train_size\n",
    "train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "X=t and Y=t+1 时的数据，并且此时的维度为 [samples, features]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use this function to prepare the train and test datasets for modeling\n",
    "look_back = 1\n",
    "trainX, trainY = create_dataset(train, look_back)\n",
    "testX, testY = create_dataset(test, look_back)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "投入到 LSTM 的 X 需要有这样的结构： [samples, time steps, features]，所以做一下变换，LSTM的输入为 [samples, timesteps, features]这里的timesteps为步数，features为维度 这里我们的数据是1维的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reshape input to be [samples, time steps, features]\n",
    "trainX = numpy.reshape(trainX, (trainX.shape[0], 1, 1))\n",
    "testX = numpy.reshape(testX, (testX.shape[0], 1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\SSYP\\Anaconda3\\envs\\lstm\\lib\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From C:\\Users\\SSYP\\Anaconda3\\envs\\lstm\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "Epoch 1/100\n",
      " - 1s - loss: 0.0401\n",
      "Epoch 2/100\n",
      " - 0s - loss: 0.0196\n",
      "Epoch 3/100\n",
      " - 0s - loss: 0.0142\n",
      "Epoch 4/100\n",
      " - 0s - loss: 0.0131\n",
      "Epoch 5/100\n",
      " - 0s - loss: 0.0120\n",
      "Epoch 6/100\n",
      " - 0s - loss: 0.0111\n",
      "Epoch 7/100\n",
      " - 0s - loss: 0.0100\n",
      "Epoch 8/100\n",
      " - 0s - loss: 0.0091\n",
      "Epoch 9/100\n",
      " - 0s - loss: 0.0080\n",
      "Epoch 10/100\n",
      " - 0s - loss: 0.0069\n",
      "Epoch 11/100\n",
      " - 0s - loss: 0.0060\n",
      "Epoch 12/100\n",
      " - 0s - loss: 0.0051\n",
      "Epoch 13/100\n",
      " - 0s - loss: 0.0044\n",
      "Epoch 14/100\n",
      " - 0s - loss: 0.0037\n",
      "Epoch 15/100\n",
      " - 0s - loss: 0.0032\n",
      "Epoch 16/100\n",
      " - 0s - loss: 0.0028\n",
      "Epoch 17/100\n",
      " - 0s - loss: 0.0025\n",
      "Epoch 18/100\n",
      " - 0s - loss: 0.0023\n",
      "Epoch 19/100\n",
      " - 0s - loss: 0.0021\n",
      "Epoch 20/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 21/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 22/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 23/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 24/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 25/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 26/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 27/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 28/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 29/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 30/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 31/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 32/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 33/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 34/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 35/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 36/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 37/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 38/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 39/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 40/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 41/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 42/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 43/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 44/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 45/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 46/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 47/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 48/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 49/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 50/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 51/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 52/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 53/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 54/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 55/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 56/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 57/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 58/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 59/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 60/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 61/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 62/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 63/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 64/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 65/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 66/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 67/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 68/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 69/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 70/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 71/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 72/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 73/100\n",
      " - 0s - loss: 0.0018\n",
      "Epoch 74/100\n",
      " - 0s - loss: 0.0021\n",
      "Epoch 75/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 76/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 77/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 78/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 79/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 80/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 81/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 82/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 83/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 84/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 85/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 86/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 87/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 88/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 89/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 90/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 91/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 92/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 93/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 94/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 95/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 96/100\n",
      " - 0s - loss: 0.0020\n",
      "Epoch 97/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 98/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 99/100\n",
      " - 0s - loss: 0.0019\n",
      "Epoch 100/100\n",
      " - 0s - loss: 0.0019\n"
     ]
    }
   ],
   "source": [
    "# create and fit the LSTM network\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, input_shape=(1, look_back)))\n",
    "# model.add(LSTM(4, input_shape=(None, look_back)))\n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)\n",
    "model.save(os.path.join(\"DATA\",\"Test\" + \".h5\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "进行预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#加载模型\n",
    "# model = load_model(os.path.join(\"DATA\",\"Test\" + \".h5\"))\n",
    "model = load_model('Test.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make predictions\n",
    "trainPredict = model.predict(trainX)\n",
    "testPredict = model.predict(testX)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#反归一化\n",
    "# invert predictions,计算误差之前要先把预测数据转换成同一单位\n",
    "trainPredict = scaler.inverse_transform(trainPredict)\n",
    "trainY = scaler.inverse_transform([trainY])\n",
    "testPredict = scaler.inverse_transform(testPredict)\n",
    "testY = scaler.inverse_transform([testY])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算 mean squared error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Score: 22.64 RMSE\n",
      "Test Score: 50.81 RMSE\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
    "print('Train Score: %.2f RMSE' % (trainScore))\n",
    "testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
    "print('Test Score: %.2f RMSE' % (testScore))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "均方根误差(RMSE)的含义是什么以及误差大小多少适合？\n",
    "RMSE实际上描述的是一种离散程度，不是绝对误差，其实就像是你射击，你开10枪，我也开10枪，你和我的总环数都是90环，你的子弹都落在离靶心差不多距离的地方，而我有几枪非常准，可是另外几枪又偏的有些离谱，这样的话我的RMSE就比你大，反映出你射击的稳定性高于我，但在仅以环数论胜负的射击比赛中，我们俩仍然是平手。这样说你应该能理解吧，基本可以理解为稳定性。那么对于你预报来说，在一个场中RMSE小说明你的模式对于所有区域的预报水平都相当，反之，RMSE较大，那么你的模式在不同区域的预报水平存在着较大的差异。\n",
    "————————————————\n",
    "版权声明：本文为CSDN博主「谁在墙外等红杏」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。\n",
    "原文链接：https://blog.csdn.net/error4o4/article/details/103822796"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "画出结果：蓝色为原数据，绿色为训练集的预测值，红色为测试集的预测值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# shift train predictions for plotting\n",
    "trainPredictPlot = numpy.empty_like(dataset)\n",
    "trainPredictPlot[:, :] = numpy.nan\n",
    "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
    "\n",
    "# shift test predictions for plotting\n",
    "testPredictPlot = numpy.empty_like(dataset)\n",
    "testPredictPlot[:, :] = numpy.nan\n",
    "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
    "\n",
    "# plot baseline and predictions\n",
    "plt.plot(scaler.inverse_transform(dataset))\n",
    "plt.plot(trainPredictPlot)\n",
    "plt.plot(testPredictPlot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分析：蓝色是原数据，橙色是training data的预测，绿色是testing data的预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.plot(trainY)\n",
    "# # plt.plot(trainPredict[1:])\n",
    "# plt.show()\n",
    "# # plt.plot(testY)\n",
    "# # plt.plot(testPredict[1:])\n",
    "# # plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ed320d72dc57c278f9f476c4e19e27ec9c3108e4a585aedf7fd164b802d178f9"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
